Nginx 安装配置

发表于 | 更新于 | 分类于 ，

yum 安装

nginx http 基本配置

cp /etc/nginx/nginx.conf{,.origin}

mkdir -p /etc/nginx/{http.d,local.d,modules.d,special.d}

http 基本配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

cat > /etc/nginx/nginx.conf << EOF

# include                   /etc/nginx/modules.d/*.conf

user                        nginx nginx;
worker_processes            auto;
worker_cpu_affinity         auto;
worker_rlimit_nofile        65535;


#worker_priority            -10;
#working_directory          /etc/nginx


pid                         /run/nginx.pid;

# nginx发生错误的日志记录，默认error，配置项有debug, info, notice, warn, error, crit, alert, or emerg。
# 最好设置为crit，因为403也会记录，太多影响性能。
error_log                   /data/log/nginx/nginx_error.log crit;


events {

    use epoll;
    multi_accept on;
    worker_connections 65535;

}


http {

    include                 mime.types;
    default_type            application/octet-stream;

    log_format              main '\$remote_addr - \$remote_user [\$time_local] "\$request" '
                                 '\$status \$body_bytes_sent "\$http_referer" '
                                 '"\$http_user_agent" "\$http_x_forwarded_for"';

    access_log              off;
    
    charset                 UTF-8;   
    
    server_tokens           off;
    sendfile                on;

    # 默认为0,没有限制，一个快速连接可能会完全占用整个工作进程。
    # NGINX不会尝试一次将整个文件发送出去，而是每次发送大小为1m的块数据。
    # 设置太小影响文件下载的速度
    #sendfile_max_chunk 1m;

    tcp_nopush              on;
    tcp_nodelay             on;

    ## 默认为off,可以不需要设置
    autoindex               off;


    # 下面一般取值10-60秒
    keepalive_timeout       65;
    client_body_timeout     10;
    client_header_timeout   10;
    send_timeout            10;
    
    reset_timedout_connection on;
    keepalive_requests      5000;

    types_hash_max_size     2048;

    # 还是采用默认值
    #server_names_hash_max_size          512;
    # 默认值32|64|128，默认值取决于处理器的高速缓存行的大小。
    #server_names_hash_bucket_size       128;          

    client_header_buffer_size           32k;
    large_client_header_buffers         4 32k;

    client_body_buffer_size             128K;
    client_max_body_size                20m;

    # client_body_temp_path path [level1 [level2 [level3]]];
    # client_body_temp_path /var/cache/nginx/client_temp 1 2;



    ## 模块配置
    include /etc/nginx/http.d/*.conf;

    ## 虚拟主机配置
    include /etc/nginx/conf.d/*.conf;

}

EOF

gzip 模块配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

cat > /etc/nginx/http.d/20.gzip.conf << EOF

    ## 开启gzip
    gzip  on;
    gzip_min_length 1k;

    #gzip_proxied any;
    gzip_proxied   expired no-cache no-store private auth;
        
    gzip_vary on;
    
    ## gzip_buffers 32 4k|16 8k;
    gzip_buffers 32 16k;

    gzip_http_version 1.0;
    gzip_comp_level 2;

    gzip_disable   'MSIE [1-6]\.';

    gzip_types text/plain text/css text/xml application/javascript application/json application/xml application/xml+rss application/xhtml+xml application/rss+xml application/atom+xml;

EOF

fastcgi模块在http中配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

mkdir -p /etc/nginx/http.d

cat > /etc/nginx/http.d/40.fastcgi.conf << EOF
    

    # fastcgi_bind 200.200.200.10;

    ## 下面三个超时，前端页面最好不要超过75秒, 后端管理页面可以指定300秒
    fastcgi_connect_timeout 65;        
    fastcgi_send_timeout 60;        
    fastcgi_read_timeout 60;
    
    fastcgi_buffers 16 64k;
    fastcgi_buffer_size 64k;        
    fastcgi_busy_buffers_size 128k;
    fastcgi_temp_file_write_size 256k;
    fastcgi_temp_path  /dev/shm/fastcgi_temp 1 2;

    ## 默认on,所以不需要设置
    # fastcgi_buffering on;

    ## 你必须明确的在error_page中指定处理方法使这个参数有效，否则nginx不会拦截
    fastcgi_intercept_errors on;


    ## fastcgi 页面缓存定义, 如果需要开启        
    # fastcgi_cache_path /dev/shm/fpm_cache levels=1:2 keys_zone=fpm_cache_key:50m inactive=30m max_size=1g;
    

EOF

fastcgi模块在location中配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

mkdir -p /etc/nginx/local.d

cat > /etc/nginx/local.d/40.fastcgi_location.conf << EOF

    ## 最好修改php.in(cgi.fix_pathinfo=0)
    ## 定义此条可以防上执行上传的php脚本
    try_files \$uri =404;


    fastcgi_split_path_info         ^(.+\.php)(.*)\$;
    fastcgi_param PATH_INFO         \$fastcgi_path_info;
    fastcgi_param SCRIPT_FILENAME   \$document_root\$fastcgi_script_name;

    fastcgi_pass                    127.0.0.1:9000;
    #fastcgi_pass                   unix:/run/php-fpm.sock;
    #fastcgi_pass                   http://upstream_app;
    
    include                         fastcgi_params;

    fastcgi_index                   index.php;

    ## 不在客户端显示php本版
    fastcgi_hide_header X-Powered-By;

    ## fastcgi_next_upstream error | timeout | invalid_header | http_500 | http_503 | http_403 | http_404 | http_429 | non_idempotent | off ...;
    ## fastcgi_next_upstream_timeout 0;
    ## fastcgi_next_upstream_tries 0;

    ## 如果需要开启fastcgi页面缓存
    ## fast_cache 缓存参数定义
    #include local.d/45.fastcgi_cache_params.conf;



EOF

fastcgi 缓存参数配置(location)

# 缓存目录会自动创建
http里参数配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

mkdir -p /etc/nginx/http.d

cat > /etc/nginx/http.d/45.fastcgi_cache.conf << EOF

    ## fastcgi 页面缓存定义, 如果需要开启

    ## 缓存目录,levels=目录层级(举例:1:2会生成16*256个字目录)
    ## keys_zone=缓存空间的名字:用多少内存,inactive=默认失效时间(10m),max_size=最多用多少硬盘空间(超过将删除最久没使用的)。
    ## use_temp_path=off，表示临时文件存放在缓存目录里。如果为on, 需要添加设置	fastcgi_temp_path path [level1 [level2 [level3]]];
    ## 只能定义在http里      
    
    fastcgi_cache_path /dev/shm/fpm_cache levels=1:2 keys_zone=fpm_cache_key:50m inactive=30m max_size=1g use_temp_path=off;
    
EOF
location里参数配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

mkdir -p /etc/nginx/local.d

cat > /etc/nginx/local.d/45.fastcgi_cache_params.conf << EOF


    ## fastcgi_cache 缓存配置参数     

    ## 定义不会从缓存中获取响应的条件。如果字符串参数的至少一个值不为空且不等于"0"，则不会从缓存中获取响应：
    fastcgi_cache_bypass \$skip_fpm_cache;

    ## 定义不将响应保存到缓存的条件。 如果字符串参数的至少一个值不为空且不等于"0"，则不会保存响应：
    fastcgi_no_cache \$skip_fpm_cache;

    ## fastcgi_cache_bypass     \$cookie_nocache \$arg_nocache\$arg_comment;
    ## fastcgi_cache_bypass     \$http_pragma    \$http_authorization;
    ## fastcgi_no_cache         \$cookie_nocache \$arg_nocache\$arg_comment;
    ## fastcgi_no_cache         \$http_pragma    \$http_authorization;


    ## 开启FastCGI缓存并指定缓存名称
    fastcgi_cache fpm_cache_key;

    ## 定义fastcgi_cache的key
    fastcgi_cache_key \$scheme\$request_method\$host\$request_uri;
    
    fastcgi_cache_valid 200 301 302 1h;
    fastcgi_cache_valid 404 500 502 503 504 0s;
    fastcgi_cache_valid any 1m;

    ## 经过多少次请求的相同URL将被缓存。
    fastcgi_cache_min_uses 2;


    ## 默认值: off
    fastcgi_cache_use_stale error timeout invalid_header http_500 http_503 updating;

    ## 请注意，在更新时必须允许使用陈旧的缓存响应。
    fastcgi_cache_background_update on;

    fastcgi_ignore_headers X-Accel-Expires Cache-Control Expires Set-Cookie;

    ## x-cache头，用于调试
    #add_header X-Cache-Status \$upstream_cache_status;
    #add_header X-Cache "\$upstream_cache_status - \$upstream_response_time";

    fastcgi_cache_lock on;

    ## 默认值5s
    fastcgi_cache_lock_age 5s;
    fastcgi_cache_lock_timeout 5s;

    ## 默认就是GET HEAD, 所以不需配置，没设置POST，post 页面就不会被缓存
    #fastcgi_cache_methods GET HEAD;

    ## 默认值off
    # fastcgi_keep_conn on;


EOF

proxy代理模块配置

location里参数配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

cat > /etc/nginx/local.d/30.proxy.conf << EOF

    ## 注意参数后面加/ 表示一个绝对的location，用来替换客户请求的url;不加/ 表示会自动添加客户请求的url.
    proxy_pass  \$scheme://images;

    proxy_redirect              off;

    proxy_set_header            Host             \$host:\$proxy_port;
    proxy_set_header            X-Real-IP        \$remote_addr;
    proxy_set_header            X-Forwarded-For  \$proxy_add_x_forwarded_for;
    proxy_set_header            X-Forwarded-Proto \$scheme;


    proxy_connect_timeout       65;
    proxy_send_timeout          65;
    proxy_read_timeout          65;

    proxy_buffer_size           64k;
    proxy_buffers               16 64k;
    proxy_busy_buffers_size     128k;

    proxy_temp_file_write_size  256k;
    proxy_temp_path             /dev/shm/proxy_temp 1 2;

    ## 默认已设置
    # proxy_buffering             on;
    # proxy_max_temp_file_size    1024m;
    # proxy_temp_path             /var/cache/nginx/proxy_temp 1 2;
    # proxy_http_version          1.0;


    ## 启用负载时用
    #proxy_next_upstream           error timeout invalid_header http_500 http_502 http_503 http_504;
    #proxy_next_upstream_timeout   0;
    #proxy_next_upstream_tries     0;



    # proxy_intercept_errors        on;
    # proxy_limit_rate              1024k;
    # proxy_headers_hash_max_size   512;
    # proxy_headers_hash_bucket_size 128;


    ## 设置不传递来自后端服务器响应的head字段给客户端
    ## proxy_hide_header field;

    ## 允许从代理服务器向客户端传递禁用的标头字段。
    ## proxy_pass_header field;


EOF

proxy代理缓存在http中配置

http里参数配置
1
2
3
4
5
6
7
8
9
10
11
12

mkdir -p /etc/nginx/http.d

cat > /etc/nginx/http.d/35.proxy_cache.conf << EOF

    ## 代理缓存定义
    ## proxy_cache_path path [levels=levels] [use_temp_path=on|off] keys_zone=name:size [inactive=time] 
    ## 只能定义在http里

    proxy_cache_path /dev/shm/proxy_cache levels=1:2 keys_zone=proxy_cache_key:250m inactive=1d max_size=1g use_temp_path=off;

EOF
location里参数配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

cat > /etc/nginx/local.d/35.proxy_cache.conf << EOF

    proxy_cache proxy_cache_key;

    proxy_cache_key \$scheme\$proxy_host\$uri\$is_args\$args;
    
    proxy_cache_min_uses        1;

    ## 确定在与代理服务器通信期间可以在哪些情况下使用过时的缓存响应。
    ## proxy_cache_use_stale error | timeout | invalid_header | updating | http_500 | http_502 | http_503 | http_504 | http_403 | http_404 | http_429 | off ...;
    proxy_cache_use_stale error timeout invalid_header updating http_500 http_502;

    proxy_cache_valid 200 301 302 1h;
    proxy_cache_valid 404 500 502 503 504 0s;
    proxy_cache_valid any 1m;

    proxy_ignore_headers X-Accel-Expires Cache-Control Expires Set-Cookie;

    ## 允许使用具有"If-Modified-Since"和"If-None-Match"头字段的条件请求重新验证过期缓存项。
    ## 默认值off
    proxy_cache_revalidate         on;
    
    ## 后面的变量值不为0 或 不是空值("")，则不从缓存取或不缓存
    #proxy_cache_bypass     \$skip_proxy_cache
    #proxy_no_cache         \$skip_proxy_cache


    proxy_cache_lock                on; 
    #proxy_cache_lock_timeout       5s;
    #proxy_cache_lock_age           5s; 

    ## X-Proxy-Cache头，用于调试
    #add_header X-Proxy-Cache \$upstream_cache_status;
    #add_header X-Proxy-Cache '$upstream_cache_status from $server_addr';
    add_header X-Proxy-Cache "\$upstream_cache_status - \$upstream_response_time";

    ## 允许启动后台子请求以更新过期的缓存项，同时将过时的缓存响应返回给客户端。
    ## 默认值为off
    #proxy_cache_background_update  on;


    
    ## 指定客户端那些方法被缓存，默认为GET|HEAD。基本不需要设置
    ## proxy_cache_methods          GET| HEAD|POST

EOF

打开文件缓存

location里参数配置
1
2
3
4
5
6
7
8
9

cat > /etc/nginx/local.d/60.open_file_cache.conf << EOF

    open_file_cache          max=10000 inactive=5m;
    open_file_cache_valid    2m;
    open_file_cache_min_uses 1;
    #open_file_cache_errors   on;

EOF

server 配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
server {



    location ~* ^.+\.(ogg|ogv|svg|svgz|eot|otf|woff|mp4|ttf|rss|atom|jpg|jpeg|gif|png|ico|zip|tgz|gz|rar|bz2|doc|xls|exe|ppt|tar|mid|midi|wav|bmp|rtf)$ {

        access_log off; log_not_found off; expires max;

    }



    location = /robots.txt { access_log off; log_not_found off; }

    location ~ /\. { deny  all; access_log off; log_not_found off; }
}

nginx http 配置说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
#包含动态模块配置文件
# include                   /etc/modules.d/*.conf

# nginx工作进程以那个用户&组权限运行
user                        nginx nginx;

# nginx 工作进程数，默认auto 自动检测，一般设置为CPU内核总数，过高也并不起到提高性能的作用
worker_processes            auto;

# 为每一个进程分配cpu,或者将一个进程分配到多个cpu。
worker_cpu_affinity         auto;

## 示例：将8 个进程分配到8 个cpu。当然能够写多个，或者将一个进程分配到多个cpu。
##worker_processes 8;
##worker_cpu_affinity 00000001 00000010 00000100 00001000 00010000 00100000 01000000 10000000;


#更改所有worker进程的最大打开最大文件数限制，受系统进程的最大打开文件数量限制（ulimit -n 65535），在 /etc/security/limits.conf 中配置。
# fs.file-max：该参数决定了系统中所允许的文件句柄最大数目，文件句柄设置代表linux系统中可以打开的文件的数量。
########################################
# $ ulimit -n
# # 查看linux系统文件描述符
# $ sudo sysctl -a | grep fs.file
# fs.file-max = 655360
# fs.file-nr = 6592	0	655360
# fs.xfs.filestream_centisecs = 3000
########################################

worker_rlimit_nofile        65535;


# 相当于nice, 取值-20/20，负数为更高优先级。
#worker_priority            -10;

# nginx工作目录，必须绝对路径，默认--prefix=path
#working_directory          /etc/nginx


#指定pid文件的位置,默认值就可以
pid                         /run/nginx.pid;

# nginx发生错误的日志记录，默认error，配置项有debug, info, notice, warn, error, crit, alert, or emerg。最好设置为crit，因为403也会记录，太多影响性能。
error_log                   /data/log/nginx/nginx_error.log crit;


events {

    # 多路复用，Linux 关键配置，允许单个线程处理多个客户端请求。
    use epoll;

    # nginx进程一次同时接收一个还是多个请求连接。需高并发的服务器开启。
    # 允许尽可能地处理更多的连接数，如果 worker_connections 配置太低，会产生大量的无效连接请求。
    multi_accept on;

    # 配置单个 Nginx 单个进程可服务的客户端数量，（最大值客户端数 = 单进程连接数 * 进程数 ）,不能超过 worker_rlimit_nofile 值
    # 最大客户端数同时也受操作系统 socket 连接数的影响（最大 64K ）
    worker_connections 65535;

}


 http {

    #使用的默认的 MIME-type
    include                 mime.types;
    default_type            application/octet-stream;

    #定义日志格式
    log_format '$remote_addr - $remote_user [$time_local] "$request" '
    '$status $body_bytes_sent "$http_referer" '
    '"$http_user_agent" "$http_x_forwarded_for"';


    # 直接关闭http日志。但不影响server 配置里的访问日志记录
    access_log              off;
    


    #设置头文件默认字符集
    charset                 UTF-8;   
    
    #Nginx打开网页报错时,关闭版本号显示
    server_tokens           off;

    # 开启 sendfile 选项，使用内核的 FD 文件传输功能，这个比在用户态用 read() + write() 的方式更加高效。
    # sendfile()可以在磁盘和TCP socket之间互相拷贝数据(或任意两个文件描述符)。
    sendfile                on;

    # 设置为非零值时，限制可以在单个sendfile（）调用中传输的数据量。 
    # 默认为0,没有限制，一个快速连接可能会完全占用整个工作进程。
    # NGINX不会尝试一次将整个文件发送出去，而是每次发送大小为1m的块数据。
    # 可以减少阻塞调用sendfile()所花费的最长时间
    # 设置太小影响文件下载的速度
    #sendfile_max_chunk 1m;

    # 打开 tcp_nopush 选项，Nginux 允许将 HTTP 应答首部与数据内容在同一个报文中发出。
    # 这个选项使服务器在 sendfile 时可以提前准备 HTTP 首部，能够达到优化吞吐的效果。
    # 告诉nginx在一个数据包里发送所有头文件，而不一个接一个的发送。
    tcp_nopush              on;

    # 不要缓存 data-sends （关闭 Nagle 算法），这个能够提高高频发送小数据报文的实时性。
    # 配置 nginx 不缓存数据，快速发送小数据
    tcp_nodelay             on;

    # 值为on, 表示开启目录列表访问，合适下载服务器，默认关闭(off)。
    # 网站为了安全，必须关闭
    autoindex off;


    # 下面一般取值10-60秒

    # HTTP连接持续时间,值越大无用的线程变的越多,0:关闭此功能,默认为75。客户端不再做任何操作，保持连接的超时时间。
    # 在http早期 ，每个http请求都要求打开一个tpc socket连接，并且使用一次之后就断开这个tcp连接。
    # 使用keep-alive可以改善这种状态，即在一次TCP连接中可以持续发送多份数据而不会 断开连接。
    # 通过使用keep-alive机制，可以减少tcp连接建立次数，也意味着可以减少TIME_WAIT状态连接，
    # 以此提高性能和提高httpd 服务器的吞吐率(更少的tcp连接意味着更少的系统内核调用,socket的accept()和close()调用)。
    # 但是，长时间的tcp连接容易导致系统资源无效占用。
    # keepalive_timout时间值意味着：一个http产生的tcp连接在传送完最后一个响应后，还需要hold住 keepalive_timeout秒后，才开始关闭这个连接。
    
    keepalive_timeout       65;


    # 定义读取客户端请求主体的超时。 
    # 超时只能在两个连续读操作之间的一段时间内设置，而不是传输整个请求主体。 
    # 如果客户端在此时间内没有传输任何内容，则408（请求超时）错误将返回给客户端。
    client_body_timeout     10;

    # 定义读取客户端请求标头的超时。 
    # 如果客户端在此时间内未传输整个报头，则408（请求超时）错误将返回给客户端。
    client_header_timeout   10;


    # 设置向客户端发送响应的超时时间。 
    # 超时只在两次连续的写入操作之间设置，而不是用于传输整个响应。
    # 如果客户端在此时间内没有收到任何内容，则连接关闭。
    send_timeout            10;
    


    # 允许服务器在客户端停止发送应答之后关闭连接，以便释放连接相应的 socket 内存开销。
    # 当有大并发需求时，建议打开。
    reset_timedout_connection on;

    # 单个客户端通过"一个存活长连接"送达的最大请求数（默认是100，建议根据客户端在"keepalive"存活时间内的总请求数来设置）
    # 当送达的请求数超过该值后，该连接就会被关闭。
    keepalive_requests      5000;
    


    # types_hash_max_size影响散列表的冲突率。
    # types_hash_max_size越大，就会消耗更多的内存，但散列key的冲突率会降低，检索速度就更快。
    # types_hash_max_size越小，消耗的内存就越小，但散列key的冲突率可能上升。

    types_hash_max_size     2048;

    # 保存服务器名字的hash表是由指令 server_names_hash_max_size 和 server_names_hash_bucket_size所控制的。
    # 参数hash bucket size总是等于hash表的大小，并且是一路处理器缓存大小的倍数。
    # 在减少了在内存中的存取次数后，使在处理器中加速查找hash表键值成为可能。
    # 如果 hash bucket size等于一路处理器缓存的大小，那么在查找键的时候，最坏的情况下在内存中查找的次数为2。
    # 第一次是确定存储单元的地址，第二次是在存储单元中查找键值。
    # 因此，如果Nginx给出需要增大 hash max size 或 hash bucket size的提示，那么首要的是增大前一个参数的大小.
    # 还是采用默认值
    #server_names_hash_max_size          512;
    #server_names_hash_bucket_size       128;          # 默认值32|64|128，默认值取决于处理器的高速缓存行的大小。

    # 客户请求头缓冲大小。一般一个请求的头部大小不会超过1k, 除非有很大的cookie。
    # 这个可以根据你的系统分页大小来设置,系统分页大小的整数倍，$ getconf PAGESIZE。64位系统默认值为16k。
    # nginx默认会用client_header_buffer_size这个buffer来读取header值，
    # 如果header过大，它会使用large_client_header_buffers来读取。
    client_header_buffer_size           32k;

    # 设置用于读取大型客户端请求标头的缓冲区的最大数量和大小。 
    # 请求行不能超过一个缓冲区的大小，或者414（Request-URI太大）错误返回给客户端。 
    # 请求头字段也不能超过一个缓冲区的大小，或者400（错误请求）错误返回给客户端。 
    # 缓冲区仅在需求时分配。 默认情况下，缓冲区大小等于8K字节。 
    # 如果请求处理结束后连接转换为保持活动状态，则释放这些缓冲区。
    # 下面取值表示最多用4组32k的内存缓冲区来存储。
    large_client_header_buffers         4 32k;

    # 此指令设置用于请求主体的缓冲区大小。 
    # 如果主体超过缓冲区大小，则完整主体或其一部分将写入临时文件。 
    # 如果NGINX配置为使用文件而不是内存缓冲区，则该指令会被忽略。 
    # 默认情况下，该指令为32位系统设置一个8k缓冲区，为64位系统设置一个16k缓冲区。 
    # 该指令在NGINX配置的http，server和location区块使用。
    client_body_buffer_size             128K;

    # 设置"Content-Length"请求标题字段中指定的客户端请求主体的最大允许大小。 
    # 此指令设置NGINX能处理的最大请求主体大小。 
    # 如果请求大于指定的大小，则NGINX发回HTTP 413（Request Entity too large）错误。 
    # 如果服务器处理大文件上传，则该指令非常重要。
    # 此参数一般用来限制上传文件的最大值。由于编码的原因，一般设置比实际上传文件大30%
    client_max_body_size                20m;


    # 如果缓冲区与请求大小相比较小，则数据将写入磁盘上的文件，因此将涉及I/O操作。 
    # 指定存储请求正文的临时文件的位置。
    # level1,2,3如果有值就代表存在一级，二级，三级子目录。
    # 目录名是由数字进行命名的，所以这里的具体的值就是代表目录名的数字位数。
    # client_body_temp_path path [level1 [level2 [level3]]];
    # client_body_temp_path /var/cache/nginx/client_temp/ 1 2;

    # 禁用NGINX缓冲区并将请求体存储在临时文件中。文件包含纯文本数据。
    # off:该值将禁用文件写入
    # clean：请求body将被写入文件。 该文件将在处理请求后删除。
    # on: 请求正文将被写入文件。 处理请求后，将不会删除该文件。
    # 默认情况下，指令值为关闭。
    # 不建议设置
    # client_body_in_file_only off

    # NGINX将完整的请求主体存储在单个缓冲区中。 默认情况下，指令值为off。 
    # 如果启用(on)，它将优化读取$request_body变量时涉及的I/O操作。
    # 不建议设置
    # client_body_in_single_buffer off


    #------------------------------------------------------




    #线程池优化,使用--with-threads配置参数编译
    #aio threads;
    #thread_pool default threads=32 max_queue=65536;
    #aio threads=default;
    #关于更多线程请点击查看


    #响应头

    add_header X-Cache $upstream_cache_status;
    #缓存命中
    add_header X-Frame-Options SAMEORIGIN;
    #是为了减少点击劫持（Clickjacking）而引入的一个响应头
    add_header X-Content-Type-Options nosniff;


    include /usr/local/nginx/conf/vhosts/*.conf;
    #在当前文件中包含另一个文件内容的指令

    #静态文件的缓存性能调优

    open_file_cache max=65535 inactive=20s;
    #这个将为打开文件指定缓存,max 指定缓存数量.建议和打开文件数一致.inactive 是指经过多长时间文件没被请求后删除缓存
    open_file_cache_valid 30s;
    #这个是指多长时间检查一次缓存的有效信息,例如我一直访问这个文件,30秒后检查是否更新,反之更新
    open_file_cache_min_uses 2;
    #定义了open_file_cache中指令参数不活动时间期间里最小的文件数
    open_file_cache_errors on;
    #NGINX可以缓存在文件访问期间发生的错误,这需要设置该值才能有效,如果启用错误缓存.则在访问资源（不查找资源）时.NGINX会报告相同的错误

    #资源缓存优化
    server {

        #防盗链设置

        location ~* \.(jpg|gif|png|swf|flv|wma|asf|mp3|mmf|zip|rar)$ {
            #防盗类型
            valid_referers none blocked *.renwole.com renwole.com;
            #none blocked参数可选.允许使用资源文件的域名
            if ($invalid_referer) {
                return 403;
                #rewrite ^/ https://www.renwole.com
                #若不符合条件域名,则返回403或404也可以是域名
            }
        }

        location ~ .*\.(js|css)$ {
            access_log off;
            expires 180d;
            #健康检查或图片.JS.CSS日志.不需要记录日志.在统计PV时是按照页面计算.而且写入频繁会消耗IO.
        }

        location ~* \.(ogg|ogv|svg|svgz|eot|otf|woff|mp4|swf|ttf|rss|atom|jpg|jpeg|gif|png|ico|zip|tgz|gz|rar|bz2|doc|xls|exe|ppt|tar|mid|midi|wav|bmp|rtf)$ {
            access_log off;
            log_not_found off;
            expires 180d;
            #视图&元素很少改变.可将内容缓存到用户本地.再次访问网站时就无需下载.节省流量.加快访问速度.缓存180天
        }
    }

    server {
        listen 80 default_server;
        server_name .renwole.com;
        rewrite ^ https://www.renwole.com$request_uri?;
    }

    server {
        listen 443 ssl http2 default_server;
        listen [::]:443 ssl http2;
        server_name .renwole.com;
        root /home/web/renwole;
        index index.html index.php;

        ssl_certificate /etc/letsencrypt/live/www.renwole.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/www.renwole.com/privkey.pem;

        ssl_dhparam /etc/nginx/ssl/dhparam.pem;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;
        ssl_ciphers 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:DES-CBC3-SHA:!DSS';

        ssl_session_cache shared:SSL:50m;
        ssl_session_timeout 1d;
        ssl_session_tickets off;
        ssl_prefer_server_ciphers on;
        add_header Strict-Transport-Security max-age=15768000;
        ssl_stapling on;
        ssl_stapling_verify on;

        include /usr/local/nginx/conf/rewrite/wordpress.conf;
        access_log /usr/local/nginx/logs/renwole.log;

        location ~ \.php$ {
            root /home/web/renwole;
            fastcgi_pass 127.0.0.1:9000;
            fastcgi_index index.php;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            include fastcgi_params;
        }
    }
 }

fastcgi 配置

fastcgi 在 http 模块配置

http 模块配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

mkdir -p /etc/nginx/http.d

cat > /etc/nginx/http.d/40.fastcgi.conf << EOF
    

    ## 指定从哪个IP地址和端口出去访问FastCGI server
    ## off 表示取消继承http或server里的配置，可以允许系统自动分配本地IP地址和端口
    ## transparent 表示允许从非本地IP地址（例如，来自客户端的真实IP地址）出去访问FastCGI服务器.
    ## 比如：fastcgi_bind $remote_addr transparent;
    ## fastcgi_bind address [transparent] | off;

    ## 下面三个超时，前端页面最好不要超过75秒, 后端页面可以指定300秒
    #连接到后端 Fastcgi 的超时时间,单位秒
    fastcgi_connect_timeout 65;
    
    #与 Fastcgi 建立连接后多久不传送数据,就会被自动断开
    fastcgi_send_timeout 60;
    
    #接收 Fastcgi 应答超时时间
    fastcgi_read_timeout 60;
    


    ## 对于单个连接，设置用于从FastCGI服务器读取响应的缓冲区的数量和大小。 
    ## 默认情况下，缓冲区大小等于一个内存页面。 这是4K或8K，取决于平台。
    ## 较大的请求将被缓冲到磁盘
    ## fastcgi_buffers 8 4k|8k;
    fastcgi_buffers 16 64k;
    
    ## 指定读取 Fastcgi 应答第一部分需要多大的缓冲区,可以设置gastcgi_buffers选项指定的缓冲区大小
    ## 默认一个内存页的大小，一般4k或8k
    fastcgi_buffer_size 64k;
    
    ## 繁忙时的buffer,可以是fastcgi_buffer的两倍
    fastcgi_busy_buffers_size 128k;

    ## 在写入fastcgi_temp_path时将用多大的数据块,默认值是fastcgi_buffers的两倍,该值越小越可能报 502 BadGateway
    fastcgi_temp_file_write_size 256k;

    #fastcgi_max_temp_file_size=1024m;
    #fastcgi_temp_path  /var/cache/nginx/fastcgi_temp 1 2;
    fastcgi_temp_path  /dev/shm/fastcgi_temp 1 2;

    ## 启用或禁用来自FastCGI服务器的响应缓冲。
    ## 启用缓冲时，nginx会尽快收到来自FastCGI服务器的响应，并将其保存到由fastcgi_buffer_size和fastcgi_buffers指令设置的缓冲区中。 
    ## 如果整个响应不适合内存，则其一部分可以保存到磁盘上的临时文件中。 
    ## 写入临时文件由fastcgi_max_temp_file_size和fastcgi_temp_file_write_size指令控制。
    ## 当禁用缓冲时，响应会在收到时立即同步传递给客户端。 nginx不会尝试从FastCGI服务器读取整个响应。 
    ## nginx一次可以从服务器接收的数据的最大大小由fastcgi_buffer_size指令设置。
    ## 通过在"X-Accel-Buffering"响应头域中通过"是"或"否"，也可以启用或禁用缓冲。 可以使用fastcgi_ignore_headers指令禁用此功能。
    ## fastcgi_buffering on | off;
    ## 默认on,所以不需要设置

    #fastcgi_buffering on;



    ## 确定FastCGI服务器对代码大于或等于300的响应是否应传递给客户端。
    ## 或者是否被拦截并重定向到nginx以便使用error_page指令进行处理。
    ## 你必须明确的在error_page中指定处理方法使这个参数有效，否则nginx不会拦截
    ## fastcgi_intercept_errors on | off;
    fastcgi_intercept_errors on;



    ## fastcgi 页面缓存定义, 如果需要开启

    ## 缓存目录,levels=目录层级(举例:1:2会生成16*256个字目录)
    ## keys_zone=缓存空间的名字:用多少内存,inactive=默认失效时间(10m),max_size=最多用多少硬盘空间(超过将删除最久没使用的)。
    ## use_temp_path=off，表示临时文件存放在缓存目录里。如果为on, 需要添加设置	fastcgi_temp_path path [level1 [level2 [level3]]];
    ## 只能定义在http里      
    
    # fastcgi_cache_path /dev/shm/fpm_cache levels=1:2 keys_zone=fpm_cache_key:50m inactive=30m max_size=1g use_temp_path=off;
    

EOF

fastcgi 在server中配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
server {
    listen          80;
    server_name     www.test.com;
    access_log      /var/log/nginx/test_access.log;
    error_log       /var/log/nginx/test_error.log;
    root            /var/www/html;
    index           index.php index.html;


    ## 如果启用fastcgi cache，这里设置过滤掉不需要的进行缓存的页面。
    ## 设置默认缓存。当然也可以设置默认不缓存，需要缓存的在通过过滤设置
    set $skip_fpm_cache 0;

    ## 这里以wordpress为例
    ## if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/feed/|index.php|sitemap(_index)?.xml") {
    ##    set $skip_fpm_cache 1;
    ## }

    location / {

    }

    location ~ \.php($|/) {
        ## fpm 处理
        include     local.d/40.fastcgi_location.conf

        ## 导入包含一些传递到FastCGI服务器的参数的文件
        include     fastcgi_params;

        ## fast_cache 缓存参数定义
        #include    local.d/45.fastcgi_cache_params.conf;
    }

    location ~* "\.(?:ogg|ogv|svg|svgz|eot|otf|woff|mp4|ttf|rss|atom|jpg|jpeg|gif|png|ico|zip|tgz|gz|rar|bz2|doc|xls|exe|ppt|tar|mid|midi|wav|bmp|rtf)$" {

        access_log off; log_not_found off; expires max;

    }

    location = /robots.txt { access_log off; log_not_found off; }

    location ~ /\. { deny  all; access_log off; log_not_found off; }        

    }

}

fastcgi 在 location 模块配置

location 模块配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

mkdir -p /etc/nginx/local.d

vi /etc/nginx/local.d/40.fastcgi_location.conf

    ## 在PHP开启「cgi.fix_pathinfo」的情况下，PHP可能会把错误的文件类型当作PHP文件来解析。存在安全问题。
    ## 最好修改php.in(cgi.fix_pathinfo=0)
    ## 定义此条可以防上执行上传图片的php脚本
    ## 比如http://www.xxx.com/fake.jpg/foo.php, 如果fake.jpg实际是一个php脚本文件，则会执行。
    try_files $uri =404;

    ## fastcgi_split_path_info regex;
    ## 只能定义在location里
    ## 定义捕获$ fastcgi_path_info变量值的正则表达式。 正则表达式应该有两个捕获：
    ## 第一个变为$ fastcgi_script_name变量的值，第二个变为$ fastcgi_path_info变量的值。 
    ## 例如，使用这些设置和"/show.php/article/0001"请求，
    ## SCRIPT_FILENAME参数将等于"/path/to/php/show.php"，
    ## 并且PATH_INFO参数将等于"/article/0001"。

    fastcgi_split_path_info         ^(.+\.php)(.*)$;
    #fastcgi_param SCRIPT_FILENAME  /path/to/php$fastcgi_script_name;
    fastcgi_param SCRIPT_FILENAME   $documet_root$fastcgi_script_name;
    fastcgi_param PATH_INFO         $fastcgi_path_info;

    ## 只能定义在location里
    ## 使用tcp连接
    fastcgi_pass        127.0.0.1:9000;

    ## 使用unix socket连接
    #fastcgi_pass       unix:/run/php-fpm.sock;
    
    ## 导入包含一些传递到FastCGI服务器的参数的文件
    #include            fastcgi_params;

    ## 定义/默认页面
    fastcgi_index       index.php;

    ## 不会传递的字段给客户端, 不在客户端显示php本版
    fastcgi_hide_header X-Powered-By;

    ###################################################
    ## 负载均衡有关

    ## fastcgi_pass http://upstream_app

    ## 指定应将请求传递到下一个服务器的情况：
    ## fastcgi_next_upstream error | timeout | invalid_header | http_500 | http_503 | http_403 | http_404 | http_429 | non_idempotent | off ...;

    ## 时间限制和尝试next upstream限制，0表示不限制
    ## fastcgi_next_upstream_timeout 0;
    ## fastcgi_next_upstream_tries 0;

    ###################################################
    ## 如果需要开启fastcgi页面缓存

    ## fast_cache 缓存参数定义
    #include local.d/45.fastcgi_cache_params.conf;

fastcgi_cache 缓存配置参数

fastcgi_cache：缓存fastcgi生成的内容，很多情况是php生成的动态的内容，少了nginx与php的通信的次数，更减轻了php和数据库
location fastcgi_cache 缓存配置参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

mkdir -p /etc/nginx/local.d

vi /etc/nginx/local.d/45.fastcgi_cache_params.conf
            
    ## fastcgi_cache 缓存配置参数     

    ## 定义不会从缓存中获取响应的条件。如果字符串参数的至少一个值不为空且不等于"0"，则不会从缓存中获取响应：
    fastcgi_cache_bypass $skip_fpm_cache;

    ## 定义不将响应保存到缓存的条件。 如果字符串参数的至少一个值不为空且不等于"0"，则不会保存响应：
    fastcgi_no_cache $skip_fpm_cache;

    ## fastcgi_cache_bypass     $cookie_nocache $arg_nocache$arg_comment;
    ## fastcgi_cache_bypass     $http_pragma    $http_authorization;
    ## fastcgi_no_cache         $cookie_nocache $arg_nocache$arg_comment;
    ## fastcgi_no_cache         $http_pragma    $http_authorization;


    ## 开启FastCGI缓存并指定缓存名称
    fastcgi_cache fpm_cache_key;

    ## 定义fastcgi_cache的key
    fastcgi_cache_key $scheme$request_method$host$request_uri;
    
    ##--------------------------------------------
    ## 为指定的http返回代码指定缓存时间。没指定代码，后面直接跟时间，表示缓存返回响应代码为200 301 302的请求的页面
    ## any 表示任意返回代码
    fastcgi_cache_valid 200 301 302 1h;
    fastcgi_cache_valid 404 500 502 503 504 0s;
    fastcgi_cache_valid any 1m;

    ## 经过多少次请求的相同URL将被缓存。
    fastcgi_cache_min_uses 6;

    ## 定义哪些情况下用过期缓存
    ## 如果无法选择要处理请求的FastCGI服务器，则error参数还允许使用过时的缓存响应。
    ## updating参数允许使用陈旧的缓存响应，如果它当前正在更新。这样可以在更新缓存数据时最大限度地减少对FastCGI服务器的访问次数。
    ## 为了最大限度地减少填充新缓存元素时对FastCGI服务器的访问次数，可以使用fastcgi_cache_lock指令。
    ## "Cache-Control"头字段的"reale-revalidate"扩展允许使用陈旧的缓存响应，如果它正在更新。
    ## "Cache-Control"头字段的"stale-if-error"扩展允许在发生错误时使用陈旧的缓存响应。
    ## 默认值: off
    fastcgi_cache_use_stale error timeout invalid_header http_500 http_503 updating;

    ## 当过时的缓存响应则返回给客户端时
    ## 允许启动后台子请求来更新过期的缓存项目。 
    ## 请注意，在更新时必须允许使用陈旧的缓存响应。
    fastcgi_cache_background_update on;


    ## 禁止处理来自FastCGI服务器的某些响应头字段。 
    ## 如果未禁用，则处理这些头字段具有以下效果：
    ##    "X-Accel-Expires"，"Expires"，"Cache-Control"，"Set-Cookie"和"Vary"   设置响应缓存的参数;
    ##    "X-Accel-Redirect"    执行内部重定向到指定的URI;
    ##    "X-Accel-Limit-Rate"  设置向客户传送回复的速率限制;
    ##    "X-Accel-Buffering"   启用或禁用缓冲响应;
    ##    "X-Accel-Charset"     设置所需的响应字符集。

    ## 有一些情况会影响到cache的命中 这里需要特别注意：
    ##  Nginx fastcgi_cache在缓存后端fastcgi响应时，当响应里包含"set-cookie"时，不缓存;
    ##  当响应头包含Expires时，如果过期时间大于当前服务器时间，则nginx_cache会缓存该响应，否则，则不缓存;
    ##  当响应头包含Cache-Control时，如果Cache-Control参数值为no-cache、no-store、private中任意一个时，则不缓存，
    ##  如果Cache-Control参数值为max-age时，会被缓存，且nginx设置的cache的过期时间，就是系统当前时间 + mag-age的值
    
    ## 有些php session设置可能会在请求头里产生不缓存标记,所以需要忽略这些请求头

    fastcgi_ignore_headers X-Accel-Expires Cache-Control Expires Set-Cookie;

    ## x-cache头，用于调试
    ## $upstream_response_time为过期时间
    ## $upstream_cache_status 变量表示此请求响应来自cache的状态，几种状态分别为：
    ##  •MISS - 在缓存中找不到响应，因此从原始服务器获取响应。然后可以缓存响应。
    ##  •BYPASS - 响应是从源服务器获取的，而不是从缓存中提供的，因为请求与proxy_cache_bypass指令匹配。
    ##  •EXPIRED - 缓存中的条目已过期。响应包含来自源服务器的新内容。
    ##  •STALE - 内容过时，因为源服务器未正确响应，并且已配置proxy_cache_use_stale。
    ##  •UPDATING - 内容过时，因为当前正在更新条目以响应先前的请求，并且配置了proxy_cache_use_stale更新。
    ##  •REVALIDATED - 启用了proxy_cache_revalidate指令，NGINX验证当前缓存的内容仍然有效（If-Modified-Since或If-None-Match）。
    ##  •HIT - 响应包含直接来自缓存的有效，新鲜内容。
    #add_header X-Cache-Status $upstream_cache_status;
    #add_header X-Cache "$upstream_cache_status - $upstream_response_time";

    ## 启用后，通过将请求传递给FastCGI服务器，一次只允许一个请求填充根据fastcgi_cache_key指令标识的新缓存元素。
    ## 同一缓存元素的其他请求将等待响应出现在缓存中或缓存锁定以释放此元素，直到fastcgi_cache_lock_timeout指令设置的时间。
    ## 如何规避大并发时锁的堵塞, 如果对数据实时性要求不太高，可以使用 fastcgi_cache_use_stale updating 设置，这样堵塞时可以使用旧数据应付.
    fastcgi_cache_lock on;

    ## 如果传递给FastCGI服务器的最后一个请求在指定时间内没有完成获取数据来更新缓存，
    ## 则将另一个请求传递给FastCGI服务器。
    fastcgi_cache_lock_age 5s;

    ## 当时间到期时，请求将被传递给FastCGI服务器，但是，响应将不会被缓存。
    fastcgi_cache_lock_timeout 5s;

    ## 默认就是GET HEAD, 所以不需配置，没设置POST，post 页面就不会被缓存
    #fastcgi_cache_methods GET HEAD;

    ## 默认情况下，FastCGI服务器将在发送响应后立即关闭连接。
    ## 但是，当此伪指令设置为on时，nginx将指示FastCGI服务器保持连接打开。 
    ## 特别是，这对于FastCGI服务器的keepalive连接起作用是必要的。比如 upstream 中使用keepalive
    ## 默认值off
    # fastcgi_keep_conn on;

    ## 限制从FastCGI服务器读取响应的速度。 速率以每秒字节数指定。零值禁用速率限制。 
    ## 根据请求设置限制，因此如果nginx同时打开两个到FastCFI服务器的连接，则总速率将是指定限制的两倍。 
    ## 仅当启用了对来自FastCGI服务器的响应的缓冲时，该限制才有效。
    # fastcgi_limit_rate 0;

    ## 使用具有"If-Modified-Since"和"If-None-Match"标头字段的条件请求启用过期缓存项的重新验证。
    #fastcgi_cache_revalidate on;

fastcgi_cache设置多个磁盘缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
## 用到ngx_http_split_clients_module 模块，此模块一般用来做AB测试的。

fastcgi_cache_path /path/to/hdd1 levels=1:2 keys_zone=my_cache_hdd1:10m max_size=10g  inactive=60m use_temp_path=off;
fastcgi_cache_path /path/to/hdd2 levels=1:2 keys_zone=my_cache_hdd2:10m max_size=10g  inactive=60m use_temp_path=off;

split_clients $request_uri $my_cache {
            50%          "my_cache_hdd1";
            50%          "my_cache_hdd2";
}

server {
    ...
    location / {
    fastcgi_cache $my_cache;
        
    }
}

缓存清理

## 方法一：直接删除缓存目录，然后还要运行nginx -s reload，来清理nginx缓存

    rm -rf /dev/shm/fpm_cache/*
    nginx -s reload


##  方法二：编译使用第三方插件，根据访问路径清理缓存

    http://labs.frickle.com/files/ngx_cache_purge-2.3.tar.gz

    https://github.com/FRiCKLE/ngx_cache_purge
location 配置
1
2
3
4
5
6
7
8

location ~ /purge(/.*) {

    fastcgi_cache_purge fpm_cache_key "$scheme$request_method$host$1";
    allow 127.0.0.1;
    deny all;

}

proxy代理模块配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

## 设置代理服务器的协议和地址以及应映射位置的可选URI。作为协议，可以指定“ http”或“ https”。该地址可以指定为域名或IP地址，以及可选端口：
## proxy_pass URL;
## 注意参数后面加/ 表示一个绝对的location，用来替换客户请求的url;不加/ 表示会自动添加客户请求的url.
proxy_pass  $scheme://images;

#Proxy Settings

## proxy_redirect [ default|off|redirect replacement ];
## 默认：proxy_redirect default;
## 当上游服务器返回的响应是重定向或刷新请求（如HTTP响应码是301或者302）时，proxy_redirect可以重设HTTP头部的location或refresh字段给客户端。

## 假设后端服务器返回给代理服务器的Location字段为http://localhost:8000/two/uri/ ，而代理服务器需要返回的是http://frontend/one/uri 给客户端。
## proxy_redirect http://localhost:8000/two/ http://frontend/one/;
## 将Location字段重写为http://frontend/one/uri/。
## 在代替的字段中可以不写服务器名：nginx会将host及port部分替换成自身的server_name及listen port，即使它来自非80端口。  
## proxy_redirect http://localhost:8000/two/ /; # 相当于(proxy_redirect http://localhost:8000/two/ http://$host:$server_port/;)
## 对于多个域名匹配的server，redirect设置不能写作’/'了，否则会用第一个域名作为redirect域名
## 如果使用"default"参数，将根据location和proxy_pass参数的设置来决定。
## 例如下列两个配置等效：
## location /one/ {
## proxy_pass       http://upstream:port/two/; 
## proxy_redirect   default; #此条设置等同于(proxy_redirect   http://upstream:port/two/   http://upstream:port/two/one/;)
## }
## prox_redirect 可以使用变量和正则，可以有用多个prox_redirect，但如果proxy_pass使用了变量，default将禁用。
## 示例：proxy_redirect http://localhost:8000/ http://$host:$server_port/;
##      proxy_redirect http://$proxy_host:8000/ /;
##      proxy_redirect ~^(http://[^:]+):\d+(/.+)$ $1$2;
##      proxy_redirect ~*/user/([^/]+)/(.+)$      http://$1.example.com/$2;
## 参数off将在这个字段中禁止所有的proxy_redirect指令.
## 一般用于后端服务器和转发目的服务器目录一致，或者转发给后端服务器自己，location路径没变。
proxy_redirect              off;

## proxy_set_header field value;
## 允许将请求header字段重新定义或附加到传递给后端服务器 。该value可以包含文本，变量，以及它们的组合
## value 为空(""),表示取消传递此header字段给后端服务器
proxy_set_header            Host             $host:$proxy_port;
proxy_set_header            X-Real-IP        $remote_addr;
proxy_set_header            X-Forwarded-For  $proxy_add_x_forwarded_for;

## 如果server 里用了ssl，客户端通过https连nginx 代理, nginx与后端服务器的通信还是http，为了让后端程序识别和使用客户端
## Most PHP, Python, Rails, Java App can use this header ##
#proxy_set_header           X-Forwarded-Proto https;
proxy_set_header            X-Forwarded-Proto $scheme;


## proxy_next_upstream error | timeout | invalid_header | http_500 | http_502 | http_503 | http_504 | http_403 | http_404 | non_idempotent | off ...;
## 指定请求应传递到下一个服务器的情况：
## error:在与服务器建立连接，向其传递请求或读取响应标头时发生错误;
## timeout:在与服务器建立连接，向其传递请求或读取响应头时发生超时;
## invalid_header:服务器返回空响应或无效响应;
## non_idempotent:通常，如果请求已经被发送到上游服务器（1.9.13），则具有非幂等方法的请求（POST，LOCK，PATCH）不被传递到下一个服务器;启用此选项明确允许重试此类请求;
## off:禁用将请求传递到下一个服务器。
proxy_next_upstream         error timeout invalid_header http_500 http_502 http_503 http_504;

## 限制请求可以传递到下一个服务器的时间。 0值关闭此限制。
# proxy_next_upstream_timeout 0;

## 限制将请求传递到下一个服务器的可能尝试次数。 0值关闭此限制。
# proxy_next_upstream_tries 0;

proxy_connect_timeout       65;
proxy_send_timeout          65;
proxy_read_timeout          65;

## 启用或禁用来自代理服务器的响应缓冲。
## 默认为on
#proxy_buffering on;

## 设置size用于读取从代理服务器接收到的响应的第一部分的缓冲区。
## 默认：proxy_buffer_size 4k | 8k;
proxy_buffer_size           32k;

## 为单个连接 设置用于从代理服务器读取响应的缓冲区number和size.
proxy_buffers               16 32k;
proxy_busy_buffers_size     128k;

## 如果buffer不够用，就写入临时文件由 proxy_max_temp_file_size和 proxy_temp_file_write_size指令控制。
proxy_temp_file_write_size  256k;

## 默认最大1024m, 可以不用设置
# proxy_max_temp_file_size    1024m;

## 定义用于存储临时文件的目录，其中包含从代理服务器接收的数据。
## 在指定目录下最多可以使用三级子目录层次结构。
## proxy_temp_path path [level1 [level2 [level3]]];
# proxy_temp_path /var/cache/nginx/proxy_temp 1 2;
proxy_temp_path  /dev/shm/proxy_temp 1 2;

## 当客户端没等到response就关闭了连接，代理服务器是否关闭与后端的连接

## 默认 proxy_ignore_client_abort 是关闭的，
## 此时在请求过程中如果客户端端主动关闭请求或者客户端网络断掉，
## 那么 Nginx 会记录 499，同时 request_time 是 「后端已经处理」的时间，而 upstream_response_time 为 “-“

## 如果使用了 proxy_ignore_client_abort on ;
## 那么客户端主动断掉连接之后，Nginx 会等待后端处理完(或者超时)，然后 记录 「后端的返回信息」 到日志。
## 所以，如果后端 返回 200， 就记录 200 ；如果后端放回 5XX ，那么就记录 5XX 。
## 如果超时(默认60s，可以用 proxy_read_timeout 设置)，Nginx 会主动断开连接，记录 504。

# proxy_ignore_client_abort on;


## proxy_intercept_errors on | off;
## 确定代码大于或等于300的代理响应是应该传递给客户端还是被拦截并重定向到nginx以便使用error_page指令进行处理。
## 默认值off
# proxy_intercept_errors on;

## proxy_limit_rate rate;
## 仅当启用了代理服务器的响应缓冲时，此限制才有效 。
## 限制从代理服务器读取响应的速度。在rate被以每秒字节数指定。零值禁用速率限制。

## 设置proxy_hide_header和proxy_set_header 指令size使用的哈希表的最大值。
## 默认：proxy_headers_hash_max_size 512;
# proxy_headers_hash_max_size 512;

## 设置proxy_hide_header和proxy_set_header 指令size使用的哈希表的存储区。
## 默认：proxy_headers_hash_bucket_size 64;
# proxy_headers_hash_bucket_size 64;


## 设置不传递来自后端服务器响应的head字段给客户端
## proxy_hide_header field;

## 允许从代理服务器向客户端传递禁用的标头字段。
## proxy_pass_header field;

## 设置代理的HTTP协议版本。默认情况下，使用版本1.0。建议将1.1版与 keepalive 连接和 NTLM身份验证配合使用。
## 默认：proxy_http_version 1.0;



## proxy_store on | off | string;
## 默认值off
## 开启将文件保存到磁盘上的功能。
## 如果设置为on，nginx将文件保存在alias指令或root指令设置的路径中。
## 如果设置为off，nginx将关闭文件保存的功能。
## 此外，保存的文件名也可以使用含变量的string参数来指定：proxy_store /data/www$original_uri;
## 保存文件的修改时间根据接收到的“Last-Modified”响应头来设置。响应都是先写到临时文件，然后进行重命名来生成的。
## 这条指令可以用于创建静态无更改文件的本地拷贝，比如：
## location /images/ {
##     root                   /data/www;
##     open_file_cache_errors off;
##     error_page             404 = @fetch;
## }

## location @fetch {
##     internal;

##     proxy_pass             http://backend/;
##     proxy_store            on;
##     proxy_store_access     user:rw group:rw all:r;
##     proxy_temp_path        /var/cache/nginx/proxy_temp 1 2;

       # 下面也可写成(root  /data/www;)
##     alias                  /data/www/; 
## }

proxy代理缓存配置

proxy_cache：缓存后端服务器的内容，可能是任何内容，包括静态的和动态，减少了nginx与后端通信的次数，节省了传输时间和后端宽带
http里配置
1
2
3
4
5
## 代理缓存定义
## proxy_cache_path path [levels=levels] [use_temp_path=on|off] keys_zone=name:size [inactive=time] 
## 只能定义在http里

# proxy_cache_path /dev/shm/proxy_cache levels=1:2 keys_zone=proxy_cache_key:250m inactive=1d max_size=1g use_temp_path=off;
location里配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

## 定义缓存的键
## proxy_cache_key "$host$request_uri$cookie_user";
proxy_cache_key $scheme$proxy_host$uri$is_args$args;

## 经过多少次请求就缓存
proxy_cache_min_uses 1;

proxy_cache_revalidate on;

## 确定在与代理服务器通信期间可以在哪些情况下使用过时的缓存响应。
## proxy_cache_use_stale error | timeout | invalid_header | updating | http_500 | http_502 | http_503 | http_504 | http_403 | http_404 | http_429 | off ...;
proxy_cache_use_stale error timeout invalid_header updating http_500 http_502 http_503 http_504;


## 设置不同响应代码的缓存时间。
## proxy_cache_valid [code ...] time;
## 如果后面只跟时间，表示只缓存200,301和302个响应。
## any 表示缓存任何响应
## 注意，直接在响应头中设置缓存的参数比这里的优先级高。

## "X-Accel-Expires"标题字段以秒为单位设置响应的缓存时间。零值禁用响应的缓存。如果值以@前缀开头，则设置自Epoch以来的绝对时间（以秒为单位），响应可以高速缓存。
## 如果标题不包括"X-Accel-Expires"字段，则可以在标题字段"Expires"或"Cache-Control"中设置高速缓存的参数。
## 如果标头包含"Set-Cookie"字段，则不会缓存此类响应。
## 如果标题包含具有特殊值" *" 的"Vary"字段，则不会缓存此类响应（1.7.7）。如果标题包含具有另一个值的"Vary"字段，则将考虑相应的请求标题字段来缓存这样的响应（1.7.7）。

proxy_cache_valid 200 301 302 10m;
proxy_cache_valid any 1m;


## 禁用从代理服务器处理某些响应头字段。
## 可以忽略以下字段："X-Accel-Redirect"，"X-Accel-Expires"，"X-Accel-Limit-Rate"（1.1.6），"X-Accel-Buffering"（1.1.6） ，"X-Accel-Charset"（1.1.6），"Expires"，"Cache-Control"，"Set-Cookie"（0.8.44）和"Vary"（1.7.7）。

## 如果未禁用，则处理这些标头字段会产生以下影响：
##  "X-Accel-Expires"，"Expires"，"Cache-Control"，"Set-Cookie"和"Vary"设置响应缓存的参数;
##  "X-Accel-Redirect"执行 内部重定向到指定的URI;
##  "X-Accel-Limit-Rate"设置向客户端传输响应的 速率限制 ;
##  "X-Accel-Buffering"启用或禁用 缓冲响应;
##  "X-Accel-Charset"设置了所需 的响应字符集。

#proxy_ignore_headers X-Accel-Expires Cache-Control Expires Set-Cookie;


## 定义在哪些情况下不从cache读取，直接从backend获取资源；配置方式同proxy_no_cache。
## 后面的变量值不为0 或 不是空值("")，则不从缓存取或不缓存
#proxy_cache_bypass     $proxy_skip_cache
#proxy_no_cache         $proxy_skip_cache

## proxy_cache_bypass   $cookie_nocache $arg_nocache $arg_comment; 
## proxy_cache_bypass   $http_pragma $http_authorization;

## proxy_no_cache       $cookie_nocache $arg_nocache $arg_comment; 
## proxy_no_cache       $http_pragma $http_authorization;

## 启用后，如果缓存过期，一次只允许一个请求传递给代理服务器, 获取数据后更新缓存，其它请求要么等待缓存更新，要么使用旧的缓存数据。
proxy_cache_lock            on; 
## 锁定超时，请求将被传递给代理的服务器，但是，响应不会被缓存。
proxy_cache_lock_timeout    5s;
## 在锁定期间内还未更新缓存，则再让下一个请求去获取更新
proxy_cache_lock_age        5s; 

## 允许启动后台子请求以更新过期的缓存项，同时将过时的缓存响应返回给客户端。
## 默认值为off
#proxy_cache_background_update on;

## 允许使用具有"If-Modified-Since"和"If-None-Match"头字段的条件请求重新验证过期缓存项。
## 默认值off
#proxy_cache_revalidate on;

## 指定客户端那些方法被缓存，默认为GET|HEAD。基本不需要设置
## proxy_cache_methods GET| HEAD|POST

## X-Proxy-Cache头，用于调试
#add_header X-Proxy-Cache \$upstream_cache_status;
#add_header X-Proxy-Cache '$upstream_cache_status from $server_addr';
add_header X-Proxy-Cache "\$upstream_cache_status - \$upstream_response_time";
## 缓存过期标记说明：

.Expires: 最原始的配置策略，即设置过期时间，但使用效率低下，目前绝大部分已经被Cache-Control（有兴趣的可以去看下http1.0和http1.1）；

.Cache-Control：定义缓存资源属性是private或者是public，并且设置缓存多久后过期，本例中，属性为public，60秒过期；

.X-Accel-Expires: 只有nginx能识别的缓存特性header，优先级大于上面两个header，可以设置此header，在nginx侧来重新定义缓存特性；

.Etag和Last-Modified是捆绑生成的: 有些场景下，你希望client端的浏览器长时间缓存，而缓存服务器只短时间缓存文件，以至于当后端服务器更新后，缓存服务器会及时同步，我们就可以使用最后两个header，Last-Modified表示最后修改时间，并声明一个ETag(哈希值)，做为缓存内容的标签，具有唯一性;客户端访问请求带有If‑Modified‑Since或者If‑None‑Match header，并申明自己的客户端带有静态缓存文件,以及文件修改日期和ETag值，如果服务器端的版本和Etag值与客户端一致，则服务端会直接返回304 not modified，这个验证流程是非常快的，并且节省网络带宽；

.如果Cache-Control设置为public，则客户端不会去验证资源的有效性，将会一直使用直到过期，同时public也代表资源可以被缓存在web proxy中；

.如果Cache-Control包含must-revalidate，则客户端每一次访问请求资源都会去验证缓存是否有更新；

打开文件缓存

## max：设置缓存中的最大元素数; 在缓存溢出时，删除最近最少使用（LRU）的元素;
## inactive：定义一个时间，如果在此期间未访问该元素，则从该缓存中删除该元素; 默认情况下，它是60秒;
open_file_cache max = 1000 inactive = 20s;

## 打开文件缓存的过期时间验证间隔
open_file_cache_valid 60s;

## 在inactive时间内，访问多少次就缓存
open_file_cache_min_uses 2;

## 启用或禁用文件查找错误的缓存，默认值off
#open_file_cache_errors on;



参考：http://www.cnblogs.com/cmfwm/p/7659179.html

Nginx 的 open_file_cache 相关配置可以缓存静态文件的元信息，在这些静态文件被频繁访问时可以显着提升性能。

注意不会缓存文件内容，只缓存文件元信息。还是慎用此功能。

被缓存的文件元信息包括：

    fd，文件被打开一次后，fd保留使用
    size
    path
    last modified time

由于 nginx 还持有原文件的 fd，所以你删除此文件后，文件并不会真正消失， client 还是能通过原路径访问此文件。即便你删除后又新建了一个同名文件，在当前缓存更新周期内能访问到的还是原文件的内容。

文件大小调整，可能导致发给客户端的信息并非是修改后文件内容。

如果你的静态文件内容变化频繁并且对时效性要求较高，一般应该把 open_file_cache_valid 设置的小一些，以便及时检测和更新。
如果变化相当不频繁的话，那就可以设置大一点，在变化后用 reload nginx 的方式来强制更新缓存。
对静态文件访问的 error 和 access log 不关心的话，可以关闭已提升效率。

location 说明

1.=开头表示精确匹配，如 A 中只匹配根目录结尾的请求，后面不能带任何字符串。
2.^~ 开头表示uri以某个常规字符串开头，不是正则匹配。
3.~ 开头表示区分大小写的正则匹配;
4.~* 开头表示不区分大小写的正则匹配
5./ 通用匹配, 如果没有其它匹配,任何请求都会匹配到

顺序 no优先级：
(location =) > (location 完整路径) > (location ^~ 路径) > (location ,* 正则顺序) > (location 部分起始路径) > (/)

压缩模块

http 模块配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

mkdir -p /etc/nginx/http.d


cat > /etc/nginx/http.d/50.gzip.conf << EOF

    ## 开启gzip
    gzip  on;

    ## 对数据启用压缩的最少字节数,如:请求小于1K文件,不要压缩,压缩小数据会降低处理此请求的所有进程速度
    gzip_min_length 1k;


    ## Nginx做为反向代理的时候启用,匹配的前提是后端服务器必须要返回包含"Via"的 header头：

    ##    off - 关闭所有的代理结果数据的压缩
    ##    expired - 启用压缩，如果header头中包含 "Expires" 头信息
    ##    no-cache - 启用压缩，如果header头中包含 "Cache-Control:no-cache" 头信息
    ##    no-store - 启用压缩，如果header头中包含 "Cache-Control:no-store" 头信息
    ##    private - 启用压缩，如果header头中包含 "Cache-Control:private" 头信息
    ##    no_last_modified - 启用压缩,如果header头中不包含 "Last-Modified" 头信息
    ##    no_etag - 启用压缩 ,如果header头中不包含 "ETag" 头信息
    ##    auth - 启用压缩 , 如果header头中包含 "Authorization" 头信息
    ##    any - 无条件启用压缩

    #gzip_proxied any;
    gzip_proxied   expired no-cache no-store private auth;
        
    ## 是否在http header中添加Vary: Accept-Encoding，建议开启,让前端的缓存服务器识别压缩后的文件,代理
    gzip_vary on;

    ## 设置用于处理请求压缩的缓冲区数量和大小。
    ## 比如32 4K表示按照内存页（one memory page）大小以4K为单位（即一个系统中内存页为4K），申请32倍的内存空间。
    ## 此项设置太小，如果需要压缩的文件超过缓存数X缓存大小，会导致数据截断。
    ## gzip_buffers 32 4k|16 8k;
    gzip_buffers 64 16k;

    ## 设置gzip压缩针对的HTTP协议版本，默认1.1。默认在http/1.0的协议下不开启gzip压缩。
    ## nginx和后端的upstream server之间默认是用HTTP/1.0协议通信的
    ## 后端的nginx上没有设置gzip_http_version为1.0，那么Cache的url将不会进行gzip压缩。
    ## 前端的nginx也要开启gzip
    gzip_http_version 1.0;

    ## gzip压缩等级在0-9内,数值越大压缩率越高,CPU消耗也就越大
    ## gzip_comp_level 1的压缩能力已经够用了，后面级别越高，压缩的比例其实增长不大，反而很吃处理性能。
    gzip_comp_level 2;

    ## 表明哪些UA头不使用gzip压缩，禁用低版本的IE浏览器启用压缩功能
    #gzip_disable "msie6";
    gzip_disable   "MSIE [1-6]\.";



    ## 进行压缩的文件类型。javascript有多种形式。其中的值可以在 mime.types 文件中找到。
    gzip_types text/plain text/css text/xml application/javascript application/json application/xml application/xml+rss application/xhtml+xml application/rss+xml application/atom+xml;



EOF

连接限制

http 模块配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

mkdir -p /etc/nginx/http.d


cat > /etc/nginx/http.d/50.limit.conf << EOF

## 白名单,代理，特别IP地址或网络
geo \$remote_addr \$whiteiplist  {
    default 1;
    101.230.0.11 0;
    10.250.250.0/24 0;
    127.0.0.1 0;
}

## 返回值为空表示不限制
map \$whiteiplist  \$limit {
    1 \$binary_remote_addr;
    0 "";
}

## 获取客户端的真是IP，会直接映射到remote_addr
real_ip_header      X-Forwarded-For;
set_real_ip_from    139.219.193.17;
#set_real_ip_from   0.0.0.0/0;
#real_ip_recursive  on;

# 状态返回444, 表示Nginx不响应客户端请求，直接丢弃。
# log level 设置为info, 这样就不会记录到错误日志里
limit_conn_zone         \$limit zone=conn:30m;
limit_conn_status       444;
limit_conn_log_level    info;

limit_req_zone          \$limit zone=perip:30m rate=5r/s;
limit_req_status        444;
limit_req_log_level     info;

EOF



## 最后编辑 /etc/nginx.conf 文件,在最后用include包含此文件

http {

    .........

    include /etc/nginx/http.d/*.conf;
    include /etc/nginx/conf.d/*.conf;

}
server 模块配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

## 在location里添加限制，一般在html php jsp 等页面处理模块添加。
## 静态资源文件由于处理速度比较开，除非极端攻击，否则不添加。

server
{
    .....
    location ~ [^/]\.php(/|$)
    {
        .....

        ## 限制某时段内保持每ip最多的连接数
        limit_conn conn 5;

        ## 限制某时段内每ip最多的页面并发请求数
        limit_req zone=perip burst=5 nodelay;

        ......
    }
    .....
}

geoip模块加载

# 需要配置在nginx.conf文件的最顶端。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 存放模块的目录

    mkdir /etc/nginx/modules -p

# 存放模块配置文件的目录

    mkdir /etc/nginx/modules.d -p

# 配置文件添加模块导入


# 安装模块

    yum install nginx-module-geoip

# 添加模块配置文件

## nginx.conf 开头添加模块
cat > /etc/nginx/modules.d/ngx_http_geoip_module.conf << EOF

load_module "modules/ngx_http_geoip_module.so";

EOF


## nginx.conf http 里头添加配置
cat > /etc/nginx/http.d/http_geoip.conf << EOF

geoip_country /etc/nginx/geoip/GeoIP.dat;

EOF
## location 中应用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


location /myip {
    default_type text/plain;
    return 200 "$remote_addr $geoip_country_name $geoip_country_code $geoip_city";
    #return 403 "if you are not a robot,please contact server admin.";
}


## 使用if判断会出现问题，这里只是一个不完善的示例
location ~ [^/]\.php(/|$)
{

    ## 利用cookie检测防范cc攻击，前提客户端浏览器必须支持cookie
    # if ($cookie_clientip != "ip_$remote_addr"){
    #  add_header Set-Cookie "clientip=ip_$remote_addr";
    #  return 301 "$scheme://$host$request_uri";
    # }

    set $adminflag 0;

    if ( $request_uri ~* "/+(?:downloader|admin)" )
    {
        set $adminflag 1;
        #rewrite ^/(.*)$ $scheme://$host/myip permanent;
    }


    if ( $geoip_country_code !~* "CN" ) {
        set $adminflag "${adminflag}1";
        #rewrite ^/(.*)$ $scheme://$host/myip permanent;
    }

    if ( $adminflag = "11" )
    {
        return 403;
    }

    ....
}

常用的标准模块

核心模块：
    core module

常用的标准模块：

    HTTP modules：
        ngx_http_core_modules http核心功能模块（重要）
        ngx_http_ssl_module http信道加密模块（重要）
        ngx_http_upstream_module http定义服务器组模块（重要）
        ngx_http_fastcgi|uWSGI|SCGI_module http web api接口模块（重要）
        ngx_http_proxy_module http反向代理模块（重要）
        ngx_http_gzip_module http gzip压缩传输模块（次一级）
        ngx_http_log_module http日志模块（次一级）
        ngx_http_referer_modulehttp防盗链模块（次一级）
        ngx_http_rewrite_module http重定向模块（次一级）
        ngx_http_access_module http权限控制模块
        ngx_http_auth_basic_module http认证模块
        ngx_http_stub_status_module http状态模块
        ngx_http_headers_module http首部信息模块

    Mail modules：
        用的少

    Stream modules：
        ngx_stream_core_module http的伪四层负载均衡模块

启用 aio 线程池

http://www.infoq.com/cn/articles/thread-pools-boost-performance-9x

http、 server，或者location上下文中包含aio threads指令即可：

    aio threads;

这是线程池的最简配置。实际上的精简版本示例如下：

    thread_pool default threads=32 max_queue=65536;
    aio threads=default;

这里定义了一个名为"default"，包含32个线程，任务队列最多支持65536个请求的线程池。

如果任务队列过载，NGINX将输出如下错误日志并拒绝请求：

    thread pool "NAME" queue overflow: N tasks waiting



http {
    thread_pool one threads=128 max_queue=0;
    thread_pool two threads=32;

    server {
        location /one {
            aio threads=one;
        }

        location /two {
            aio threads=two;
        }
    }
…
}


https://www.cnblogs.com/felixzh/category/882480.html

nginx http2 介绍

https://blog.csdn.net/zhuyiquan/article/details/52585941